const fs = require('fs');

// callback hell 回调地狱
fs.readFile('./mock/data.json', (err, data) => {
  const name = JSON.parse(data.toString()).name;
  fs.readFile(name, (err, data) => {
    const name = JSON.parse(data.toString()).name;
    fs.readFile(name, (err, data) => {
      const name = JSON.parse(data.toString()).name;
    })
  })
})

function getData(fn) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve('i miss you!')
    }, 3000)
  })
}
// 将异步代码以同步的方式输出
// async 返回一个promise对象
// await 字段必须放置在async函数中
async function getFnData() {
  let data = await getData()
  console.log(data, 'data')
}
getFnData()

// // 回调函数模式 卧底模式
// getData().then(res => {
//   console.log(res, 'res')
// })

//  
/** 
 * 回调函数-：
 *  1. 一个函数 
 *  2. 作为参数 
 *  3. 传递到了其他函数中 
 *  4. 执行了
 * */

// 函数在执行的过程中-：将实参 传递给 形参

// promise模式
function myFs(src) {
  return new Promise((resolve, reject) => {
    fs.readFile(src, (err, data) => {
      resolve(JSON.parse(data.toString()).name)
    })
  })
}

myFs('./mock/data.json')
  .then(res => {
    return myFs(res)
  })
  .then(res => {
    return myFs(res)
  })
  .then(res => {
    // console.log(res, 'res')
  })
// *

// async awiat  异步函数 解决异步问题的终极方案
// 以同步的方式书写异步代码
const readFile = async () => {
  const data = await myFs('./mock/data.json')
  const data1 = await myFs(data)
  const data2 = await myFs(data1)
  return data2;
}

// await后面后面可以跟一个promise对象
// await必须放在async函数中；
// async 函数返回promise对象
readFile().then(res => {
  // console.log(res, 'res----1')
})


// function getData() {
//   setTimeout(() => {
//     return 'i miss you'
//   }, 3000)
// }

// console.log(getData())

